#ifndef JCQUEUE_DEFINE_H
#define JCQUEUE_DEFINE_H

#include <list>
#include <mutex>

using namespace std;
#include <list>
#include <mutex>
#include <condition_variable>
#include <chrono>

template <class T>
class JCMediaQueue
{
public:
    JCMediaQueue(size_t maxSize = 2000) : m_maxSize(maxSize) {}

    ~JCMediaQueue() = default;

    void enqueue(const T &t)
    {
        std::unique_lock<std::mutex> lock(m_mutex);

        // 等待直到队列有空间，超时时长为5秒
        if (m_condition_empty.wait_for(lock, std::chrono::milliseconds(5), [this]
        { return m_list.size() < m_maxSize; }))
        {
            m_list.push_back(t);
            // 通知一个在等待中的消费者
            m_condition_full.notify_one();
        }
    }

    T dequeue()
    {
        std::unique_lock<std::mutex> lock(m_mutex);

        // 等待直到队列不为空，超时时长为5秒
        if (m_condition_full.wait_for(lock, std::chrono::milliseconds(5), [this]
        { return !m_list.empty(); }))
        {
            T t = m_list.front();
            m_list.pop_front();
            // 通知一个在等待中的生产者
            m_condition_empty.notify_one();
            return t;
        }
        else
        {
            // 处理超时逻辑
            return T(); // 返回一个默认构造的对象，需要T支持默认构造
        }
    }

    bool isEmpty()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_list.empty();
    }

    size_t size()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_list.size();
    }

private:
    std::list<T> m_list;
    size_t m_maxSize; // 队列的最大容量
    std::mutex m_mutex;
    std::condition_variable m_condition_empty; // 用于通知队列有空位
    std::condition_variable m_condition_full;  // 用于通知队列不为空
};

#endif // JCQUEUE_DEFINE_H